import 'dart:async';
import 'package:flutter/material.dart';
import 'package:get/get.dart';
import 'package:xh_danmu/xh_danmu.dart';
import '../../../widgets/custom_danmu_components.dart';

enum DanmuMode {
  normal, // 普通演示
  performance, // 性能测试
  custom, // 自定义样式
  debug, // 调试模式
}

class DanmuPageController extends GetxController {
  // 弹幕控制器
  late XhDanmuController danmuController;

  // 弹幕配置
  late XhDanmuConfig danmuConfig;

  // 弹幕流控制器
  late XhDanmuStreamController streamController;

  // 页面状态
  final currentMode = DanmuMode.normal.obs;
  final isInitialized = false.obs;

  // UI状态
  final showStatus = false.obs;
  final showTrackBorders = false.obs;
  final showDebugInfo = false.obs;
  final autoSendEnabled = false.obs;

  // 性能统计
  final sentCount = 0.obs;
  final fps = 0.obs;

  // 自动发送定时器
  Worker? _autoSendWorker;
  Timer? _autoSendTimer;

  @override
  void onInit() {
    super.onInit();
    _initializePage();
  }

  @override
  void onClose() {
    // 停止自动发送
    _stopAutoSend();

    // 关闭流控制器
    streamController.close();

    // 停止弹幕动画和清理资源
    if (isInitialized.value) {
      danmuController.clearAllDanmu();
      danmuController.stopAnimation();
      Get.delete<XhDanmuController>(tag: 'danmu_page');
    }

    super.onClose();
    print('DanmuPageController 已销毁，所有资源已清理');
  }

  /// 初始化页面
  void _initializePage() {
    // 获取路由参数
    final modeParam = Get.parameters['mode'] ?? 'normal';
    currentMode.value = _parseModeFromString(modeParam);

    // 创建配置
    danmuConfig = _createConfigForMode(currentMode.value);

    // 创建弹幕流控制器
    streamController = XhDanmuStreamController();

    // 创建弹幕控制器
    danmuController = Get.put(
      XhDanmuController(),
      tag: 'danmu_page',
    );

    // 启用调试模式以查看点击日志
    danmuController.enableDebugMode();

    // 连接流控制器到弹幕控制器
    danmuController.connectStream(streamController.stream);

    // 根据模式进行额外配置
    _configureForMode(currentMode.value);

    isInitialized.value = true;

    // 调试日志
    if (currentMode.value == DanmuMode.debug) {
      print('弹幕页面初始化完成: ${currentMode.value}');
    }
  }

  /// 解析模式字符串
  DanmuMode _parseModeFromString(String mode) {
    switch (mode) {
      case 'performance':
        return DanmuMode.performance;
      case 'custom':
        return DanmuMode.custom;
      case 'debug':
        return DanmuMode.debug;
      default:
        return DanmuMode.normal;
    }
  }

  /// 为不同模式创建配置
  XhDanmuConfig _createConfigForMode(DanmuMode mode) {
    switch (mode) {
      case DanmuMode.performance:
        return const XhDanmuConfig(
          trackCount: 8,
          trackHeight: 50.0, // 增加轨道高度以容纳自定义组件
          trackSpacing: 5.0, // 增加轨道间距避免重叠
          minSpacing: 15.0,
          speed: 80.0,
          targetFps: 30,
        );

      case DanmuMode.custom:
        return XhDanmuConfig(
          trackCount: 5,
          trackHeight: 70.0, // 增加轨道高度以容纳大型自定义组件
          trackSpacing: 10.0, // 增加轨道间距避免重叠
          minSpacing: 25.0,
          speed: 60.0,
        );

      case DanmuMode.debug:
        showTrackBorders.value = true;
        showDebugInfo.value = true;
        showStatus.value = true;
        return const XhDanmuConfig(
          trackCount: 6,
          trackHeight: 60.0, // 增加轨道高度
          trackSpacing: 8.0,
          minSpacing: 20.0,
          speed: 50.0,
          targetFps: 60,
        );

      default: // normal
        return const XhDanmuConfig(
          trackCount: 6,
          trackHeight: 60.0, // 增加轨道高度以容纳自定义组件
          trackSpacing: 8.0, // 增加轨道间距避免重叠
          minSpacing: 20.0,
          speed: 60.0,
          targetFps: 30,
        );
    }
  }

  /// 根据模式进行额外配置
  void _configureForMode(DanmuMode mode) {
    switch (mode) {
      case DanmuMode.debug:
        danmuController.enableDebugMode();
        break;
      case DanmuMode.performance:
        _startPerformanceTest();
        break;
      default:
        break;
    }
  }

  /// 开始性能测试
  void _startPerformanceTest() {
    // 延迟启动自动发送，确保页面完全初始化
    Future.delayed(const Duration(milliseconds: 500), () {
      if (isInitialized.value) {
        autoSendEnabled.value = true;
        _startAutoSend();
      }
    });
  }

  /// 发送弹幕（通过Stream）
  void sendDanmu(String text, {Color? color, double? fontSize}) {
    if (!isInitialized.value) return;

    final component = SimpleTextDanmuComponent(
      id: 'manual_${DateTime.now().millisecondsSinceEpoch}',
      text: text,
      color: color ?? Colors.white,
      fontSize: fontSize ?? 16.0,
      clickable: true,
      extra: {
        'source': 'manual_send',
      },
    );
    streamController.addComponent(component);

    sentCount.value++;
  }

  /// 发送测试弹幕
  void sendTestDanmu() {
    final testTexts = _getTestTextsForMode();
    final randomText = testTexts[DateTime.now().millisecond % testTexts.length];
    final component = SimpleTextDanmuComponent(
      id: 'test_${DateTime.now().millisecondsSinceEpoch}',
      text: randomText,
      color: Colors.white,
      clickable: true,
    );
    danmuController.sendDanmuComponent(component);
  }

  /// 发送VIP弹幕
  void sendVipDanmu() {
    final component = VipDanmuComponent(
      id: 'vip_${DateTime.now().millisecondsSinceEpoch}',
      username: 'VIP用户${DateTime.now().millisecond % 100}',
      message: '这是一条VIP专属弹幕',
      level: (DateTime.now().millisecond % 20) + 1,
    );
    streamController.addComponent(component);
  }

  /// 发送礼物弹幕
  void sendGiftDanmu() {
    final gifts = ['玫瑰花', '跑车', '火箭', '城堡', '皇冠'];
    final icons = ['🌹', '🚗', '🚀', '🏰', '👑'];
    final giftIndex = DateTime.now().millisecond % gifts.length;

    final component = GiftDanmuComponent(
      id: 'gift_${DateTime.now().millisecondsSinceEpoch}',
      gifterName: '土豪${DateTime.now().millisecond % 100}',
      giftName: gifts[giftIndex],
      giftCount: (DateTime.now().millisecond % 10) + 1,
      giftIcon: icons[giftIndex],
    );
    streamController.addComponent(component);
  }

  /// 发送系统通知
  void sendSystemNotice() {
    final notices = [
      {'title': '系统通知', 'content': '弹幕系统运行正常'},
      {'title': '活动提醒', 'content': '限时活动即将开始'},
      {'title': '安全提示', 'content': '请注意保护个人信息'},
    ];
    final notice = notices[DateTime.now().millisecond % notices.length];

    final component = SystemNoticeDanmuComponent(
      id: 'notice_${DateTime.now().millisecondsSinceEpoch}',
      title: notice['title']!,
      content: notice['content']!,
      icon: Icons.campaign,
      backgroundColor: Colors.indigo,
    );
    streamController.addComponent(component);
  }

  /// 获取测试文本
  List<String> _getTestTextsForMode() {
    switch (currentMode.value) {
      case DanmuMode.performance:
        return [
          '性能测试弹幕',
          '高并发测试',
          '压力测试中',
          '负载测试',
          '流畅度检验',
        ];
      case DanmuMode.custom:
        return [
          '自定义样式展示',
          '多彩弹幕效果',
          '创意文字显示',
          '个性化设计',
          '炫酷弹幕特效',
        ];
      case DanmuMode.debug:
        return [
          '调试模式测试',
          '碰撞检测验证',
          '轨道分配测试',
          '性能监控',
          '状态实时更新',
        ];
      default:
        return [
          '欢迎使用XH弹幕',
          '高性能弹幕系统',
          '智能轨道分配',
          '严格碰撞检测',
          '完全离屏清理',
        ];
    }
  }

  /// 批量发送弹幕
  void sendBatchDanmu(int count) {
    for (int i = 0; i < count; i++) {
      Future.delayed(Duration(milliseconds: i * 200), () {
        sendTestDanmu();
      });
    }
  }

  /// 清空所有弹幕
  void clearAllDanmu() {
    if (!isInitialized.value) return;
    danmuController.clearAllDanmu();
    sentCount.value = 0;
  }

  /// 切换播放状态
  void togglePlayback() {
    if (!isInitialized.value) return;

    if (danmuController.isPlaying) {
      danmuController.pauseAnimation();
    } else {
      danmuController.startAnimation();
    }
  }

  /// 切换状态显示
  void toggleStatus() {
    showStatus.toggle();
  }

  /// 切换轨道边界显示
  void toggleTrackBorders() {
    showTrackBorders.toggle();
  }

  /// 切换调试信息显示
  void toggleDebugInfo() {
    showDebugInfo.toggle();
  }

  /// 切换自动发送
  void toggleAutoSend() {
    if (autoSendEnabled.value) {
      // 当前是开启状态，要关闭
      autoSendEnabled.value = false;
      _stopAutoSend();
    } else {
      // 当前是关闭状态，要开启
      autoSendEnabled.value = true;
      _startAutoSend();
    }
  }

  /// 开始自动发送
  void _startAutoSend() {
    _stopAutoSend(); // 先停止之前的

    // 使用周期性Timer而不是递归Future.delayed
    _autoSendTimer = Timer.periodic(
      const Duration(milliseconds: 800),
      (timer) {
        if (autoSendEnabled.value && isInitialized.value) {
          // 通过Stream发送测试弹幕
          final testTexts = _getTestTextsForMode();
          final randomText = testTexts[DateTime.now().millisecond % testTexts.length];
          final component = SimpleTextDanmuComponent(
            id: 'auto_${DateTime.now().millisecondsSinceEpoch}',
            text: randomText,
            color: Colors.primaries[DateTime.now().millisecond % Colors.primaries.length],
            clickable: true,
            extra: {
              'source': 'auto_send',
              'mode': currentMode.value.toString(),
            },
          );
          streamController.addComponent(component);
        } else {
          timer.cancel();
        }
      },
    );
  }

  /// 停止自动发送
  void _stopAutoSend() {
    _autoSendWorker?.dispose();
    _autoSendWorker = null;

    _autoSendTimer?.cancel();
    _autoSendTimer = null;
  }

  /// 获取状态信息
  XhDanmuStatus? getStatus() {
    if (!isInitialized.value) return null;
    return danmuController.getStatus();
  }

  /// 打印调试状态
  void printDebugStatus() {
    if (!isInitialized.value) return;
    danmuController.debugPrintStatus();
  }

  /// 获取当前模式显示名称
  String get currentModeDisplayName {
    switch (currentMode.value) {
      case DanmuMode.performance:
        return '性能测试模式';
      case DanmuMode.custom:
        return '自定义样式模式';
      case DanmuMode.debug:
        return '调试模式';
      default:
        return '普通演示模式';
    }
  }

  /// 获取模式描述
  String get currentModeDescription {
    switch (currentMode.value) {
      case DanmuMode.performance:
        return '测试高并发弹幕性能和系统稳定性';
      case DanmuMode.custom:
        return '展示丰富的弹幕样式定制效果';
      case DanmuMode.debug:
        return '可视化调试工具和实时状态监控';
      default:
        return '基本弹幕功能演示和体验';
    }
  }
}
